home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 September / PCWorld_2008-09_cd.bin / v cisle / sadanastroju / lightning-0.8-tb-win.xpi / chrome / calendar.jar / content / calendar / calendar-ui-utils.js < prev    next >
Encoding:
JavaScript  |  2008-02-19  |  13.7 KB  |  403 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is Sun Microsystems code.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  *   Philipp Kewisch <mozilla@kewis.ch>
  18.  * Portions created by the Initial Developer are Copyright (C) 2008
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Berend Cornelius <berend.cornelius@sun.com>
  23.  *
  24.  * Alternatively, the contents of this file may be used under the terms of
  25.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27.  * in which case the provisions of the GPL or the LGPL are applicable instead
  28.  * of those above. If you wish to allow use of your version of this file only
  29.  * under the terms of either the GPL or the LGPL, and not to allow others to
  30.  * use your version of this file under the terms of the MPL, indicate your
  31.  * decision by deleting the provisions above and replace them with the notice
  32.  * and other provisions required by the GPL or the LGPL. If you do not delete
  33.  * the provisions above, a recipient may use your version of this file under
  34.  * the terms of any one of the MPL, the GPL or the LGPL.
  35.  *
  36.  * ***** END LICENSE BLOCK ***** */
  37.  
  38. /**
  39.  * Helper function for filling the form,
  40.  * Set the value of a property of a XUL element
  41.  *
  42.  * @param aElement      ID of XUL element to set, or the element node itself
  43.  * @param aNewValue     value to set property to ( if undefined no change is made )
  44.  * @param aPropertyName OPTIONAL name of property to set, default is "value",
  45.  *                        use "checked" for radios & checkboxes, "data" for
  46.  *                        drop-downs
  47.  */
  48. function setElementValue(aElement, aNewValue, aPropertyName) {
  49.     var undefined;
  50.  
  51.     if (aNewValue !== undefined) {
  52.         if (typeof(aElement) == "string") {
  53.             aElement = document.getElementById(aElement);
  54.         }
  55.  
  56.         if (aNewValue === false) {
  57.             try {
  58.                 aElement.removeAttribute(aPropertyName);
  59.             } catch (e) {
  60.                 dump("setFieldValue: aElement.removeAttribute couldn't remove " +
  61.                 aPropertyName + " from " + aElement.localName + " e: " + e + "\n");
  62.             }
  63.         } else if (aPropertyName) {
  64.             try {
  65.                 aElement.setAttribute(aPropertyName, aNewValue);
  66.             } catch (e) {
  67.                 dump("setFieldValue: aElement.setAttribute couldn't set " +
  68.                 aPropertyName + " from " + aElement.localName + " to " + aNewValue +
  69.                 " e: " + e + "\n");
  70.             }
  71.         } else {
  72.             aElement.value = aNewValue;
  73.         }
  74.      }
  75.  }
  76.  
  77. /**
  78.  * Helper function for getting data from the form,
  79.  * Get the value of a property of a XUL element
  80.  *
  81.  * @param aElement      ID of XUL element to set, or the element node itself
  82.  * @param propertyName  OPTIONAL name of property to set, default is "value",
  83.  *                        use "checked" for radios & checkboxes, "data" for
  84.  *                        drop-downs
  85.  * @return newValue     Value of property
  86.  *
  87.  */
  88. function getElementValue(aElement, aPropertyName) {
  89.     if (typeof(aElement) == "string") {
  90.         aElement = document.getElementById(aElement);
  91.     }
  92.     return aElement[aPropertyName || "value"];
  93. }
  94.  
  95. /**
  96.  * Unconditionally show the element (hidden attribute)
  97.  *
  98.  * @param aElement      ID of XUL element to set, or the element node itself
  99.  */
  100. function showElement(aElement) {
  101.     setElementValue(aElement, false, "hidden");
  102. }
  103.  
  104. /**
  105.  * Unconditionally hide the element (hidden attribute)
  106.  *
  107.  * @param aElement      ID of XUL element to set, or the element node itself
  108.  */
  109. function hideElement(aElement) {
  110.     setElementValue(aElement, "true", "hidden");
  111. }
  112.  
  113. /**
  114.  * Unconditionally enable the element (hidden attribute)
  115.  *
  116.  * @param aElement      ID of XUL element to set, or the element node itself
  117.  */
  118. function enableElement(aElement) {
  119.     setElementValue(aElement, false, "disabled");
  120. }
  121.  
  122. /**
  123.  * Unconditionally disable the element (hidden attribute)
  124.  *
  125.  * @param aElement      ID of XUL element to set, or the element node itself
  126.  */
  127. function disableElement(aElement) {
  128.     setElementValue(aElement, "true", "disabled");
  129. }
  130.  
  131. /**
  132.  * This function unconditionally disables the element for
  133.  * which the id has been passed as argument. Furthermore, it
  134.  * remembers who was responsible for this action by using
  135.  * the given key (lockId). In case the control should be
  136.  * enabled again the lock gets removed, but the control only
  137.  * gets enabled if *all* possibly held locks have been removed.
  138.  */
  139. function disableElementWithLock(elementId,lockId) {
  140.  
  141.     // unconditionally disable the element.
  142.     disableElement(elementId);
  143.  
  144.     // remember that this element has been locked with
  145.     // the key passed as argument. we keep a primitive
  146.     // form of ref-count in the attribute 'lock'.
  147.     var element = document.getElementById(elementId);
  148.     if (element) {
  149.         if (!element.hasAttribute(lockId)) {
  150.             element.setAttribute(lockId, "true");
  151.             var n = parseInt(element.getAttribute("lock") || 0);
  152.             element.setAttribute("lock", n + 1);
  153.         }
  154.     }
  155. }
  156.  
  157. /**
  158.  * This function is intended to be used in tandem with the
  159.  * above defined function 'disableElementWithLock()'.
  160.  * See the respective comment for further details.
  161.  */
  162. function enableElementWithLock(elementId, lockId) {
  163.  
  164.     var element = document.getElementById(elementId);
  165.     if (!element) {
  166.         dump("unable to find " + elementId + "\n");
  167.         return;
  168.     }
  169.  
  170.     if (element.hasAttribute(lockId)) {
  171.         element.removeAttribute(lockId);
  172.         var n = parseInt(element.getAttribute("lock") || 0) - 1;
  173.         if (n > 0) {
  174.             element.setAttribute("lock", n);
  175.         } else {
  176.             element.removeAttribute("lock");
  177.         }
  178.         if (n <= 0) {
  179.             enableElement(elementId);
  180.         }
  181.     }
  182. }
  183.  
  184.  
  185. /** 
  186.  * Unchecks the commands of the child elements of a DOM-tree-node e.g of a menu
  187.  *
  188.  * @param aEvent    The event from which the target is taken to retrieve the
  189.  *                    child elements
  190.  */
  191. function uncheckChildNodes(aEvent) {
  192.     var liveList = aEvent.target.getElementsByAttribute("checked", "true");
  193.     for (var i = liveList.length - 1; i >= 0; i-- ) {
  194.         var commandName = liveList.item(i).getAttribute("command");
  195.         var command = document.getElementById(commandName);
  196.         if (command) {
  197.             command.setAttribute("checked", "false");
  198.         }
  199.     }
  200. }
  201.  
  202. /**
  203.  * Fills up a menu - either a menupopup or a menulist - with menuitems that refer
  204.  * to calendars.
  205.  *
  206.  * @param aItem                 The event or task
  207.  * @param aCalendarMenuParent   The direct parent of the menuitems - either a
  208.  *                                menupopup or a menulist
  209.  * @param aCalendarToUse        The default-calendar
  210.  * @param aOnCommand            A string that is applied to the "oncommand" 
  211.  *                                attribute of each menuitem
  212.  * @return                      The index of the calendar that matches the
  213.  *                                default-calendar. By default 0 is returned.
  214.  */
  215. function appendCalendarItems(aItem, aCalendarMenuParent, aCalendarToUse, aOnCommand) {
  216.     var calendarToUse = aCalendarToUse || aItem.calendar;
  217.     var calendars = getCalendarManager().getCalendars({});
  218.     var indexToSelect = 0;
  219.     var index = -1;
  220.     for (var i = 0; i < calendars.length; ++i) {
  221.         var calendar = calendars[i];
  222.         if (calendar.id == calendarToUse.id ||
  223.             (calendar &&
  224.              isCalendarWritable(calendar) &&
  225.              isItemSupported(aItem, calendar))) {
  226.             var menuitem = addMenuItem(aCalendarMenuParent, calendar.name, calendar.name);
  227.             menuitem.calendar = calendar;
  228.             index++;
  229.             if (aOnCommand) {
  230.                 menuitem.setAttribute("oncommand", aOnCommand);
  231.             }
  232.             if (aCalendarMenuParent.localName == "menupopup") {
  233.                 menuitem.setAttribute("type", "checkbox");
  234.             }
  235.             if (calendarToUse && calendarToUse.id == calendar.id) {
  236.                 indexToSelect = index;
  237.             }
  238.         }
  239.     }
  240.     return indexToSelect;
  241. }
  242.  
  243. function appendCategoryItems(aItem, aCategoryMenuList, aCommand) {
  244.     var categoriesList = getPrefCategoriesArray();
  245.  
  246.     // 'split'may return an array containing one
  247.     // empty string, rather than an empty array. This results in an empty
  248.     // menulist item with no corresponding category.
  249.     if (categoriesList.length == 1 && !categoriesList[0].length) {
  250.         categoriesList.pop();
  251.     }
  252.  
  253.     // insert the category already in the menulist so it doesn't get lost
  254.     if (aItem) {
  255.         var itemProperty = aItem.getProperty("CATEGORIES");
  256.         if (itemProperty) {
  257.             var itemCategories = categoriesStringToArray(itemProperty);
  258.             for each (var itemCategory in itemCategories) {
  259.                 if (!categoriesList.some(function(cat){ return cat == itemCategory; })){
  260.                     categoriesList.push(itemCategory);
  261.                 }
  262.             }
  263.         }
  264.         sortArrayByLocaleCollator(categoriesList);
  265.     }
  266.     
  267.     while (aCategoryMenuList.hasChildNodes()) {
  268.        aCategoryMenuList.removeChild(aCategoryMenuList.lastChild);
  269.     }
  270.  
  271.     var indexToSelect = 0;
  272.     var menuitem = addMenuItem(aCategoryMenuList, calGetString("calendar", "None"), "NONE", aCommand);
  273.     if (aCategoryMenuList.localName == "menupopup") {
  274.         menuitem.setAttribute("type", "checkbox");
  275.     }
  276.     for (var i in categoriesList) {
  277.         var menuitem = addMenuItem(aCategoryMenuList, categoriesList[i], categoriesList[i], aCommand);
  278.         if (aCategoryMenuList.localName == "menupopup") {
  279.             menuitem.setAttribute("type", "checkbox");
  280.         }
  281.         if (itemCategory && categoriesList[i] == itemCategory) {
  282.             indexToSelect = parseInt(i) + 1;  // Add 1 because of 'None'
  283.         }
  284.     }
  285.     return indexToSelect;
  286. }
  287.  
  288. function addMenuItem(aParent, aLabel, aValue, aCommand) {
  289.     if (aParent.localName == "menupopup") {
  290.         var item = document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul", "menuitem");
  291.         item.setAttribute("label", aLabel);
  292.         if (aValue) {
  293.             item.value = aValue;
  294.         }
  295.         if (aCommand) {
  296.           item.command = aCommand;
  297.         }
  298.         aParent.appendChild(item);
  299.     }
  300.     else if (aParent.localName == "menulist") {
  301.         item = aParent.appendItem(aLabel, aValue);
  302.     }
  303.     return item;
  304. }
  305.  
  306. function setCategory(aItem, aMenuElement) {
  307.     // Category
  308.     var category = getElementValue(aMenuElement);
  309.  
  310.     if (category != "NONE") {
  311.        setItemProperty(aItem, "CATEGORIES", categoriesArrayToString([category]));
  312.     } else {
  313.        aItem.deleteProperty("CATEGORIES");
  314.     }
  315. }
  316.  
  317. function processEnableCheckbox(checkboxId, elementId) {
  318.     var checked = document.getElementById(checkboxId).checked;
  319.     setElementValue(elementId, !checked && "true", "disabled");
  320. }
  321.  
  322. /**
  323.  *  Enable/disable button if there are children in a listbox
  324.  */
  325. function updateListboxDeleteButton(listboxId, buttonId) {
  326.     var rowCount = document.getElementById(listboxId).getRowCount();
  327.     setElementValue(buttonId, rowCount < 1 && "true", "disabled");
  328. }
  329.  
  330. /**
  331.  *  Update plural singular menu items
  332.  */
  333. function updateMenuLabels(lengthFieldId, menuId ) {
  334.     var field = document.getElementById(lengthFieldId);
  335.     var menu  = document.getElementById(menuId);
  336.  
  337.     // figure out whether we should use singular or plural
  338.     var length = field.value;
  339.  
  340.     var newLabelNumber;
  341.  
  342.     // XXX This assumes that "0 days, minutes, etc." is plural in other languages.
  343.     if ( (Number(length) == 0) || (Number(length) > 1) ) {
  344.         newLabelNumber = "label2"
  345.     } else {
  346.         newLabelNumber = "label1"
  347.     }
  348.  
  349.     // see what we currently show and change it if required
  350.     var oldLabelNumber = menu.getAttribute("labelnumber");
  351.  
  352.     if (newLabelNumber != oldLabelNumber) {
  353.         // remember what we are showing now
  354.         menu.setAttribute("labelnumber", newLabelNumber);
  355.  
  356.         // update the menu items
  357.         var items = menu.getElementsByTagName("menuitem");
  358.  
  359.         for (var i = 0; i < items.length; ++i) {
  360.             var menuItem = items[i];
  361.             var newLabel = menuItem.getAttribute(newLabelNumber);
  362.             menuItem.label = newLabel;
  363.             menuItem.setAttribute("label", newLabel);
  364.         }
  365.  
  366.         // force the menu selection to redraw
  367.         var saveSelectedIndex = menu.selectedIndex;
  368.         menu.selectedIndex = -1;
  369.         menu.selectedIndex = saveSelectedIndex;
  370.     }
  371. }
  372.  
  373. /**
  374.  * Select value in menuList.  Throws string if no such value.
  375.  */
  376. function menuListSelectItem(menuListId, value) {
  377.     var menuList = document.getElementById(menuListId);
  378.     var index = menuListIndexOf(menuList, value);
  379.     if (index != -1) {
  380.         menuList.selectedIndex = index;
  381.     } else {
  382.         throw "menuListSelectItem: No such Element: "+value;
  383.     }
  384. }
  385.  
  386. /**
  387.  * Find index of menuitem with the given value, or return -1 if not found.
  388.  */
  389. function menuListIndexOf(menuList, value) {
  390.     var items = menuList.menupopup.childNodes;
  391.     var index = -1;
  392.     for (var i = 0; i < items.length; i++) {
  393.         var element = items[i];
  394.         if (element.nodeName == "menuitem") {
  395.             index++;
  396.         }
  397.         if (element.getAttribute("value") == value) {
  398.             return index;
  399.         }
  400.     }
  401.     return -1; // not found
  402. }
  403.